<?php

/**
 * PHPExcel
 *
 * Copyright (c) 2006 - 2014 PHPExcel
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * @category	PHPExcel
 * @package		PHPExcel_Chart_Renderer
 * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
 * @version		1.8.0, 2014-03-02
 */


require_once(PHPExcel_Settings::getChartRendererPath().'/jpgraph.php');


/**
 * PHPExcel_Chart_Renderer_jpgraph
 *
 * @category	PHPExcel
 * @package		PHPExcel_Chart_Renderer
 * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 */
class PHPExcel_Chart_Renderer_jpgraph
{
	private static $_width	= 640;

	private static $_height	= 480;

	private static $_colourSet = array( 'mediumpurple1',	'palegreen3',	'gold1',		'cadetblue1',
										'darkmagenta',		'coral',		'dodgerblue3',	'eggplant',
										'mediumblue',		'magenta',		'sandybrown',	'cyan',
										'firebrick1',		'forestgreen',	'deeppink4',	'darkolivegreen',
										'goldenrod2'
										);

										private static $_markSet = array(	'diamond'	=> MARK_DIAMOND,
										'square'	=> MARK_SQUARE,
										'triangle'	=> MARK_UTRIANGLE,
										'x'			=> MARK_X,
										'star'		=> MARK_STAR,
										'dot'		=> MARK_FILLEDCIRCLE,
										'dash'		=> MARK_DTRIANGLE,
										'circle'	=> MARK_CIRCLE,
										'plus'		=> MARK_CROSS
										);


										private $_chart	= null;

										private $_graph	= null;

										private static $_plotColour	= 0;

										private static $_plotMark	= 0;


										private function _formatPointMarker($seriesPlot,$markerID) {
											$plotMarkKeys = array_keys(self::$_markSet);
											if (is_null($markerID)) {
												//	Use default plot marker (next marker in the series)
												self::$_plotMark %= count(self::$_markSet);
												$seriesPlot->mark->SetType(self::$_markSet[$plotMarkKeys[self::$_plotMark++]]);
											} elseif ($markerID !== 'none') {
												//	Use specified plot marker (if it exists)
												if (isset(self::$_markSet[$markerID])) {
													$seriesPlot->mark->SetType(self::$_markSet[$markerID]);
												} else {
													//	If the specified plot marker doesn't exist, use default plot marker (next marker in the series)
													self::$_plotMark %= count(self::$_markSet);
													$seriesPlot->mark->SetType(self::$_markSet[$plotMarkKeys[self::$_plotMark++]]);
												}
											} else {
												//	Hide plot marker
												$seriesPlot->mark->Hide();
											}
											$seriesPlot->mark->SetColor(self::$_colourSet[self::$_plotColour]);
											$seriesPlot->mark->SetFillColor(self::$_colourSet[self::$_plotColour]);
											$seriesPlot->SetColor(self::$_colourSet[self::$_plotColour++]);

											return $seriesPlot;
										}	//	function _formatPointMarker()


										private function _formatDataSetLabels($groupID, $datasetLabels, $labelCount, $rotation = '') {
											$datasetLabelFormatCode = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getFormatCode();
											if (!is_null($datasetLabelFormatCode)) {
												//	Retrieve any label formatting code
												$datasetLabelFormatCode = stripslashes($datasetLabelFormatCode);
											}

											$testCurrentIndex = 0;
											foreach($datasetLabels as $i => $datasetLabel) {
												if (is_array($datasetLabel)) {
													if ($rotation == 'bar') {
														$datasetLabels[$i] = implode(" ",$datasetLabel);
													} else {
														$datasetLabel = array_reverse($datasetLabel);
														$datasetLabels[$i] = implode("\n",$datasetLabel);
													}
												} else {
													//	Format labels according to any formatting code
													if (!is_null($datasetLabelFormatCode)) {
														$datasetLabels[$i] = PHPExcel_Style_NumberFormat::toFormattedString($datasetLabel,$datasetLabelFormatCode);
													}
												}
												++$testCurrentIndex;
											}

											return $datasetLabels;
										}	//	function _formatDataSetLabels()


										private function _percentageSumCalculation($groupID,$seriesCount) {
											//	Adjust our values to a percentage value across all series in the group
											for($i = 0; $i < $seriesCount; ++$i) {
												if ($i == 0) {
													$sumValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
												} else {
													$nextValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
													foreach($nextValues as $k => $value) {
														if (isset($sumValues[$k])) {
															$sumValues[$k] += $value;
														} else {
															$sumValues[$k] = $value;
														}
													}
												}
											}

											return $sumValues;
										}	//	function _percentageSumCalculation()


										private function _percentageAdjustValues($dataValues,$sumValues) {
											foreach($dataValues as $k => $dataValue) {
												$dataValues[$k] = $dataValue / $sumValues[$k] * 100;
											}

											return $dataValues;
										}	//	function _percentageAdjustValues()


										private function _getCaption($captionElement) {
											//	Read any caption
											$caption = (!is_null($captionElement)) ? $captionElement->getCaption() : NULL;
											//	Test if we have a title caption to display
											if (!is_null($caption)) {
												//	If we do, it could be a plain string or an array
												if (is_array($caption)) {
													//	Implode an array to a plain string
													$caption = implode('',$caption);
												}
											}
											return $caption;
										}	//	function _getCaption()


										private function _renderTitle() {
											$title = $this->_getCaption($this->_chart->getTitle());
											if (!is_null($title)) {
												$this->_graph->title->Set($title);
											}
										}	//	function _renderTitle()


										private function _renderLegend() {
											$legend = $this->_chart->getLegend();
											if (!is_null($legend)) {
												$legendPosition = $legend->getPosition();
												$legendOverlay = $legend->getOverlay();
												switch ($legendPosition) {
													case 'r'	:
														$this->_graph->legend->SetPos(0.01,0.5,'right','center');	//	right
														$this->_graph->legend->SetColumns(1);
														break;
													case 'l'	:
														$this->_graph->legend->SetPos(0.01,0.5,'left','center');	//	left
														$this->_graph->legend->SetColumns(1);
														break;
													case 't'	:
														$this->_graph->legend->SetPos(0.5,0.01,'center','top');	//	top
														break;
													case 'b'	:
														$this->_graph->legend->SetPos(0.5,0.99,'center','bottom');	//	bottom
														break;
													default		:
														$this->_graph->legend->SetPos(0.01,0.01,'right','top');	//	top-right
														$this->_graph->legend->SetColumns(1);
														break;
												}
											} else {
												$this->_graph->legend->Hide();
											}
										}	//	function _renderLegend()


										private function _renderCartesianPlotArea($type='textlin') {
											$this->_graph = new Graph(self::$_width,self::$_height);
											$this->_graph->SetScale($type);

											$this->_renderTitle();

											//	Rotate for bar rather than column chart
											$rotation = $this->_chart->getPlotArea()->getPlotGroupByIndex(0)->getPlotDirection();
											$reverse = ($rotation == 'bar') ? true : false;

											$xAxisLabel = $this->_chart->getXAxisLabel();
											if (!is_null($xAxisLabel)) {
												$title = $this->_getCaption($xAxisLabel);
												if (!is_null($title)) {
													$this->_graph->xaxis->SetTitle($title,'center');
													$this->_graph->xaxis->title->SetMargin(35);
													if ($reverse) {
														$this->_graph->xaxis->title->SetAngle(90);
														$this->_graph->xaxis->title->SetMargin(90);
													}
												}
											}

											$yAxisLabel = $this->_chart->getYAxisLabel();
											if (!is_null($yAxisLabel)) {
												$title = $this->_getCaption($yAxisLabel);
												if (!is_null($title)) {
													$this->_graph->yaxis->SetTitle($title,'center');
													if ($reverse) {
														$this->_graph->yaxis->title->SetAngle(0);
														$this->_graph->yaxis->title->SetMargin(-55);
													}
												}
											}
										}	//	function _renderCartesianPlotArea()


										private function _renderPiePlotArea($doughnut = False) {
											$this->_graph = new PieGraph(self::$_width,self::$_height);

											$this->_renderTitle();
										}	//	function _renderPiePlotArea()


										private function _renderRadarPlotArea() {
											$this->_graph = new RadarGraph(self::$_width,self::$_height);
											$this->_graph->SetScale('lin');

											$this->_renderTitle();
										}	//	function _renderRadarPlotArea()


										private function _renderPlotLine($groupID, $filled = false, $combination = false, $dimensions = '2d') {
											$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();

											$labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
											if ($labelCount > 0) {
												$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
												$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
												$this->_graph->xaxis->SetTickLabels($datasetLabels);
											}

											$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
											$seriesPlots = array();
											if ($grouping == 'percentStacked') {
												$sumValues = $this->_percentageSumCalculation($groupID,$seriesCount);
											}

											//	Loop through each data series in turn
											for($i = 0; $i < $seriesCount; ++$i) {
												$dataValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
												$marker = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getPointMarker();

												if ($grouping == 'percentStacked') {
													$dataValues = $this->_percentageAdjustValues($dataValues,$sumValues);
												}

												//	Fill in any missing values in the $dataValues array
												$testCurrentIndex = 0;
												foreach($dataValues as $k => $dataValue) {
													while($k != $testCurrentIndex) {
														$dataValues[$testCurrentIndex] = null;
														++$testCurrentIndex;
													}
													++$testCurrentIndex;
												}

												$seriesPlot = new LinePlot($dataValues);
												if ($combination) {
													$seriesPlot->SetBarCenter();
												}

												if ($filled) {
													$seriesPlot->SetFilled(true);
													$seriesPlot->SetColor('black');
													$seriesPlot->SetFillColor(self::$_colourSet[self::$_plotColour++]);
												} else {
													//	Set the appropriate plot marker
													$this->_formatPointMarker($seriesPlot,$marker);
												}
												$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($i)->getDataValue();
												$seriesPlot->SetLegend($dataLabel);

												$seriesPlots[] = $seriesPlot;
											}

											if ($grouping == 'standard') {
												$groupPlot = $seriesPlots;
											} else {
												$groupPlot = new AccLinePlot($seriesPlots);
											}
											$this->_graph->Add($groupPlot);
										}	//	function _renderPlotLine()


										private function _renderPlotBar($groupID, $dimensions = '2d') {
											$rotation = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotDirection();
											//	Rotate for bar rather than column chart
											if (($groupID == 0) && ($rotation == 'bar')) {
												$this->_graph->Set90AndMargin();
											}
											$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();

											$labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
											if ($labelCount > 0) {
												$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
												$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount, $rotation);
												//	Rotate for bar rather than column chart
												if ($rotation == 'bar') {
													$datasetLabels = array_reverse($datasetLabels);
													$this->_graph->yaxis->SetPos('max');
													$this->_graph->yaxis->SetLabelAlign('center','top');
													$this->_graph->yaxis->SetLabelSide(SIDE_RIGHT);
												}
												$this->_graph->xaxis->SetTickLabels($datasetLabels);
											}


											$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
											$seriesPlots = array();
											if ($grouping == 'percentStacked') {
												$sumValues = $this->_percentageSumCalculation($groupID,$seriesCount);
											}

											//	Loop through each data series in turn
											for($j = 0; $j < $seriesCount; ++$j) {
												$dataValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($j)->getDataValues();
												if ($grouping == 'percentStacked') {
													$dataValues = $this->_percentageAdjustValues($dataValues,$sumValues);
												}

												//	Fill in any missing values in the $dataValues array
												$testCurrentIndex = 0;
												foreach($dataValues as $k => $dataValue) {
													while($k != $testCurrentIndex) {
														$dataValues[$testCurrentIndex] = null;
														++$testCurrentIndex;
													}
													++$testCurrentIndex;
												}

												//	Reverse the $dataValues order for bar rather than column chart
												if ($rotation == 'bar') {
													$dataValues = array_reverse($dataValues);
												}
												$seriesPlot = new BarPlot($dataValues);
												$seriesPlot->SetColor('black');
												$seriesPlot->SetFillColor(self::$_colourSet[self::$_plotColour++]);
												if ($dimensions == '3d') {
													$seriesPlot->SetShadow();
												}
												if (!$this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($j)) {
													$dataLabel = '';
												} else {
													$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($j)->getDataValue();
												}
												$seriesPlot->SetLegend($dataLabel);

												$seriesPlots[] = $seriesPlot;
											}
											//	Reverse the plot order for bar rather than column chart
											if (($rotation == 'bar') && (!($grouping == 'percentStacked'))) {
												$seriesPlots = array_reverse($seriesPlots);
											}

											if ($grouping == 'clustered') {
												$groupPlot = new GroupBarPlot($seriesPlots);
											} elseif ($grouping == 'standard') {
												$groupPlot = new GroupBarPlot($seriesPlots);
											} else {
												$groupPlot = new AccBarPlot($seriesPlots);
												if ($dimensions == '3d') {
													$groupPlot->SetShadow();
												}
											}

											$this->_graph->Add($groupPlot);
										}	//	function _renderPlotBar()


										private function _renderPlotScatter($groupID,$bubble) {
											$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();
											$scatterStyle = $bubbleSize = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();

											$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
											$seriesPlots = array();

											//	Loop through each data series in turn
											for($i = 0; $i < $seriesCount; ++$i) {
												$dataValuesY = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex($i)->getDataValues();
												$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();

												foreach($dataValuesY as $k => $dataValueY) {
													$dataValuesY[$k] = $k;
												}

												$seriesPlot = new ScatterPlot($dataValuesX,$dataValuesY);
												if ($scatterStyle == 'lineMarker') {
													$seriesPlot->SetLinkPoints();
													$seriesPlot->link->SetColor(self::$_colourSet[self::$_plotColour]);
												} elseif ($scatterStyle == 'smoothMarker') {
													$spline = new Spline($dataValuesY,$dataValuesX);
													list($splineDataY,$splineDataX) = $spline->Get(count($dataValuesX) * self::$_width / 20);
													$lplot = new LinePlot($splineDataX,$splineDataY);
													$lplot->SetColor(self::$_colourSet[self::$_plotColour]);

													$this->_graph->Add($lplot);
												}

												if ($bubble) {
													$this->_formatPointMarker($seriesPlot,'dot');
													$seriesPlot->mark->SetColor('black');
													$seriesPlot->mark->SetSize($bubbleSize);
												} else {
													$marker = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getPointMarker();
													$this->_formatPointMarker($seriesPlot,$marker);
												}
												$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($i)->getDataValue();
												$seriesPlot->SetLegend($dataLabel);

												$this->_graph->Add($seriesPlot);
											}
										}	//	function _renderPlotScatter()


										private function _renderPlotRadar($groupID) {
											$radarStyle = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();

											$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
											$seriesPlots = array();

											//	Loop through each data series in turn
											for($i = 0; $i < $seriesCount; ++$i) {
												$dataValuesY = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex($i)->getDataValues();
												$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
												$marker = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getPointMarker();

												$dataValues = array();
												foreach($dataValuesY as $k => $dataValueY) {
													$dataValues[$k] = implode(' ',array_reverse($dataValueY));
												}
												$tmp = array_shift($dataValues);
												$dataValues[] = $tmp;
												$tmp = array_shift($dataValuesX);
												$dataValuesX[] = $tmp;

												$this->_graph->SetTitles(array_reverse($dataValues));

												$seriesPlot = new RadarPlot(array_reverse($dataValuesX));

												$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($i)->getDataValue();
												$seriesPlot->SetColor(self::$_colourSet[self::$_plotColour++]);
												if ($radarStyle == 'filled') {
													$seriesPlot->SetFillColor(self::$_colourSet[self::$_plotColour]);
												}
												$this->_formatPointMarker($seriesPlot,$marker);
												$seriesPlot->SetLegend($dataLabel);

												$this->_graph->Add($seriesPlot);
											}
										}	//	function _renderPlotRadar()


										private function _renderPlotContour($groupID) {
											$contourStyle = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();

											$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
											$seriesPlots = array();

											$dataValues = array();
											//	Loop through each data series in turn
											for($i = 0; $i < $seriesCount; ++$i) {
												$dataValuesY = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex($i)->getDataValues();
												$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();

												$dataValues[$i] = $dataValuesX;
											}
											$seriesPlot = new ContourPlot($dataValues);

											$this->_graph->Add($seriesPlot);
										}	//	function _renderPlotContour()


										private function _renderPlotStock($groupID) {
											$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
											$plotOrder = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotOrder();

											$dataValues = array();
											//	Loop through each data series in turn and build the plot arrays
											foreach($plotOrder as $i => $v) {
												$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($v)->getDataValues();
												foreach($dataValuesX as $j => $dataValueX) {
													$dataValues[$plotOrder[$i]][$j] = $dataValueX;
												}
											}
											if(empty($dataValues)) {
												return;
											}

											$dataValuesPlot = array();
											// Flatten the plot arrays to a single dimensional array to work with jpgraph
											for($j = 0; $j < count($dataValues[0]); $j++) {
												for($i = 0; $i < $seriesCount; $i++) {
													$dataValuesPlot[] = $dataValues[$i][$j];
												}
											}

											// Set the x-axis labels
											$labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
											if ($labelCount > 0) {
												$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
												$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
												$this->_graph->xaxis->SetTickLabels($datasetLabels);
											}

											$seriesPlot = new StockPlot($dataValuesPlot);
											$seriesPlot->SetWidth(20);

											$this->_graph->Add($seriesPlot);
										}	//	function _renderPlotStock()


										private function _renderAreaChart($groupCount, $dimensions = '2d') {
											require_once('jpgraph_line.php');

											$this->_renderCartesianPlotArea();

											for($i = 0; $i < $groupCount; ++$i) {
												$this->_renderPlotLine($i,True,False,$dimensions);
											}
										}	//	function _renderAreaChart()


										private function _renderLineChart($groupCount, $dimensions = '2d') {
											require_once('jpgraph_line.php');

											$this->_renderCartesianPlotArea();

											for($i = 0; $i < $groupCount; ++$i) {
												$this->_renderPlotLine($i,False,False,$dimensions);
											}
										}	//	function _renderLineChart()


										private function _renderBarChart($groupCount, $dimensions = '2d') {
											require_once('jpgraph_bar.php');

											$this->_renderCartesianPlotArea();

											for($i = 0; $i < $groupCount; ++$i) {
												$this->_renderPlotBar($i,$dimensions);
											}
										}	//	function _renderBarChart()


										private function _renderScatterChart($groupCount) {
											require_once('jpgraph_scatter.php');
											require_once('jpgraph_regstat.php');
											require_once('jpgraph_line.php');

											$this->_renderCartesianPlotArea('linlin');

											for($i = 0; $i < $groupCount; ++$i) {
												$this->_renderPlotScatter($i,false);
											}
										}	//	function _renderScatterChart()


										private function _renderBubbleChart($groupCount) {
											require_once('jpgraph_scatter.php');

											$this->_renderCartesianPlotArea('linlin');

											for($i = 0; $i < $groupCount; ++$i) {
												$this->_renderPlotScatter($i,true);
											}
										}	//	function _renderBubbleChart()


										private function _renderPieChart($groupCount, $dimensions = '2d', $doughnut = False, $multiplePlots = False) {
											require_once('jpgraph_pie.php');
											if ($dimensions == '3d') {
												require_once('jpgraph_pie3d.php');
											}

											$this->_renderPiePlotArea($doughnut);

											$iLimit = ($multiplePlots) ? $groupCount : 1;
											for($groupID = 0; $groupID < $iLimit; ++$groupID) {
												$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();
												$exploded = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();
												if ($groupID == 0) {
													$labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
													if ($labelCount > 0) {
														$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
														$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
													}
												}

												$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
												$seriesPlots = array();
												//	For pie charts, we only display the first series: doughnut charts generally display all series
												$jLimit = ($multiplePlots) ? $seriesCount : 1;
												//	Loop through each data series in turn
												for($j = 0; $j < $jLimit; ++$j) {
													$dataValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($j)->getDataValues();

													//	Fill in any missing values in the $dataValues array
													$testCurrentIndex = 0;
													foreach($dataValues as $k => $dataValue) {
														while($k != $testCurrentIndex) {
															$dataValues[$testCurrentIndex] = null;
															++$testCurrentIndex;
														}
														++$testCurrentIndex;
													}

													if ($dimensions == '3d') {
														$seriesPlot = new PiePlot3D($dataValues);
													} else {
														if ($doughnut) {
															$seriesPlot = new PiePlotC($dataValues);
														} else {
															$seriesPlot = new PiePlot($dataValues);
														}
													}

													if ($multiplePlots) {
														$seriesPlot->SetSize(($jLimit-$j) / ($jLimit * 4));
													}

													if ($doughnut) {
														$seriesPlot->SetMidColor('white');
													}

													$seriesPlot->SetColor(self::$_colourSet[self::$_plotColour++]);
													if (count($datasetLabels) > 0)
													$seriesPlot->SetLabels(array_fill(0,count($datasetLabels),''));
													if ($dimensions != '3d') {
														$seriesPlot->SetGuideLines(false);
													}
													if ($j == 0) {
														if ($exploded) {
															$seriesPlot->ExplodeAll();
														}
														$seriesPlot->SetLegends($datasetLabels);
													}

													$this->_graph->Add($seriesPlot);
												}
											}
										}	//	function _renderPieChart()


										private function _renderRadarChart($groupCount) {
											require_once('jpgraph_radar.php');

											$this->_renderRadarPlotArea();

											for($groupID = 0; $groupID < $groupCount; ++$groupID) {
												$this->_renderPlotRadar($groupID);
											}
										}	//	function _renderRadarChart()


										private function _renderStockChart($groupCount) {
											require_once('jpgraph_stock.php');

											$this->_renderCartesianPlotArea('intint');

											for($groupID = 0; $groupID < $groupCount; ++$groupID) {
												$this->_renderPlotStock($groupID);
											}
										}	//	function _renderStockChart()


										private function _renderContourChart($groupCount,$dimensions) {
											require_once('jpgraph_contour.php');

											$this->_renderCartesianPlotArea('intint');

											for($i = 0; $i < $groupCount; ++$i) {
												$this->_renderPlotContour($i);
											}
										}	//	function _renderContourChart()


										private function _renderCombinationChart($groupCount,$dimensions,$outputDestination) {
											require_once('jpgraph_line.php');
											require_once('jpgraph_bar.php');
											require_once('jpgraph_scatter.php');
											require_once('jpgraph_regstat.php');
											require_once('jpgraph_line.php');

											$this->_renderCartesianPlotArea();

											for($i = 0; $i < $groupCount; ++$i) {
												$dimensions = null;
												$chartType = $this->_chart->getPlotArea()->getPlotGroupByIndex($i)->getPlotType();
												switch ($chartType) {
													case 'area3DChart' :
														$dimensions = '3d';
													case 'areaChart' :
														$this->_renderPlotLine($i,True,True,$dimensions);
														break;
													case 'bar3DChart' :
														$dimensions = '3d';
													case 'barChart' :
														$this->_renderPlotBar($i,$dimensions);
														break;
													case 'line3DChart' :
														$dimensions = '3d';
													case 'lineChart' :
														$this->_renderPlotLine($i,False,True,$dimensions);
														break;
													case 'scatterChart' :
														$this->_renderPlotScatter($i,false);
														break;
													case 'bubbleChart' :
														$this->_renderPlotScatter($i,true);
														break;
													default	:
														$this->_graph = null;
														return false;
												}
											}

											$this->_renderLegend();

											$this->_graph->Stroke($outputDestination);
											return true;
										}	//	function _renderCombinationChart()


										public function render($outputDestination) {
											self::$_plotColour = 0;

											$groupCount = $this->_chart->getPlotArea()->getPlotGroupCount();

											$dimensions = null;
											if ($groupCount == 1) {
												$chartType = $this->_chart->getPlotArea()->getPlotGroupByIndex(0)->getPlotType();
											} else {
												$chartTypes = array();
												for($i = 0; $i < $groupCount; ++$i) {
													$chartTypes[] = $this->_chart->getPlotArea()->getPlotGroupByIndex($i)->getPlotType();
												}
												$chartTypes = array_unique($chartTypes);
												if (count($chartTypes) == 1) {
													$chartType = array_pop($chartTypes);
												} elseif (count($chartTypes) == 0) {
													echo 'Chart is not yet implemented<br />';
													return false;
												} else {
													return $this->_renderCombinationChart($groupCount,$dimensions,$outputDestination);
												}
											}

											switch ($chartType) {
												case 'area3DChart' :
													$dimensions = '3d';
												case 'areaChart' :
													$this->_renderAreaChart($groupCount,$dimensions);
													break;
												case 'bar3DChart' :
													$dimensions = '3d';
												case 'barChart' :
													$this->_renderBarChart($groupCount,$dimensions);
													break;
												case 'line3DChart' :
													$dimensions = '3d';
												case 'lineChart' :
													$this->_renderLineChart($groupCount,$dimensions);
													break;
												case 'pie3DChart' :
													$dimensions = '3d';
												case 'pieChart' :
													$this->_renderPieChart($groupCount,$dimensions,False,False);
													break;
												case 'doughnut3DChart' :
													$dimensions = '3d';
												case 'doughnutChart' :
													$this->_renderPieChart($groupCount,$dimensions,True,True);
													break;
												case 'scatterChart' :
													$this->_renderScatterChart($groupCount);
													break;
												case 'bubbleChart' :
													$this->_renderBubbleChart($groupCount);
													break;
												case 'radarChart' :
													$this->_renderRadarChart($groupCount);
													break;
												case 'surface3DChart' :
													$dimensions = '3d';
												case 'surfaceChart' :
													$this->_renderContourChart($groupCount,$dimensions);
													break;
												case 'stockChart' :
													$this->_renderStockChart($groupCount,$dimensions);
													break;
												default	:
													echo $chartType.' is not yet implemented<br />';
													return false;
											}
											$this->_renderLegend();

											$this->_graph->Stroke($outputDestination);
											return true;
										}	//	function render()


										/**
										 * Create a new PHPExcel_Chart_Renderer_jpgraph
										 */
										public function __construct(PHPExcel_Chart $chart)
										{
											$this->_graph	= null;
											$this->_chart	= $chart;
										}	//	function __construct()

}	//	PHPExcel_Chart_Renderer_jpgraph
